// 线程库的封装
#include <iostream>
#include "Thread.hpp"
#include <vector>
using namespace ThreadModule;

void print(int& cnt)
{
    while(cnt)
    {
        std::cout << "Hello, I am myself thread, cnt: " << cnt << std::endl;
        cnt--;
        sleep(1);
    }
}

// 使用vector管理一批线程
const int num = 5;
int main()
{
    std::vector<Thread<int>> threads;
    // 创建一批线程
    for(int i = 1; i <= 5; i++)
    {
        std::string name = "thread-" + std::to_string(i);
        //Thread<int> t(print, 10, name);
        int data = 10;
        threads.emplace_back(print, data, name);
    }

    // 启动一批线程
    for(auto& thread: threads)
    {
        thread.Start();
    }

    // 等待一批线程
    for(auto& thread: threads)
    {
        thread.Join();
        std::cout << "wait thread done, thread is: " << thread.name() << std::endl;
    }

    return 0;
}

// int main()
// {
//     int cnt = 10;
//     Thread<int> t1(print, cnt);
//     t1.Start();
//     t1.Join();
//     return 0;
// }






// #include <iostream>
// #include <pthread.h>
// #include <unistd.h>
// #include <vector>
// #include <string>
// 
// 
// // 返回值和参数的传递
// const int threadNum = 5;
// 
// 
// // 参数的设计
// class Task
// {
// public:
//     Task(int x = 1, int y = 2)
//         :_x(x), _y(y)
//     {}
// 
//     int Excute()
//     {
//         return _x + _y;
//     }
//     ~Task()
//     {}
// 
// private:
//     int _x;
//     int _y;
// };
// 
// class ThreadData
// {
// public:
//     ThreadData(int x, int y, const std::string& threadName)
//         :_threadName(threadName), _t(x, y)
//     {}
// 
//     int run()
//     {
//         return _t.Excute();
//     }
// 
//     ~ThreadData()
//     {}
//     const std::string& threadName()
//     {
//         return _threadName;
//     }
// private:
//     std::string _threadName;
//     Task _t;
// };
// 
// // 返回值的设计
// class Result
// {
// public:
//     Result()
//     {}
// 
//     ~Result()
//     {}
// 
//     void SetResult(int result, const std::string& threadName)
//     {
//         _result = result;
//         _threadName = threadName;
//     }
// 
//     void Print()
//     {
//         std::cout << _threadName << ": " << _result << std::endl; 
//     }
// 
// private:
//     int _result;
//     std::string _threadName;
// };
// 
// 
// void* handlerTask(void* args)
// {
//     ThreadData* td = static_cast<ThreadData*>(args);
// 
//     std::string name = td->threadName();
// 
//     Result* res = new Result();
//     int result = td->run();
// 
//     res->SetResult(result, name);
// 
//     delete td;
//     sleep(2);
//     return res; // 返回一个指向堆空间的值
// }
// 
// int main()
// {
//     std::vector<pthread_t> threads;
//     for(int i = 0; i < threadNum; i++)
//     {
//         char threadName[64];
//         snprintf(threadName, sizeof(threadName), "Thread-%d", i+1);
//         ThreadData* td = new ThreadData(10, 20, threadName);
// 
//         pthread_t tid;
//         pthread_create(&tid, nullptr, handlerTask, td); // 创建线程
//         threads.push_back(tid); // 保存线程ID
//     }
//     std::vector<Result*> result_set; // 保存每个线程返回的结果
//     void* ret = nullptr;
//     for(auto& id: threads)
//     {
//         pthread_join(id, &ret); // 等待线程，并获取返回值
//         result_set.push_back((Result*)ret); // 保存返回值
//     }
// 
//     // 查看线程的返回值
//     for(auto& ret: result_set)
//     {
//         ret->Print();
//         delete ret;
//     }
//     return 0;
// }



// const int threadNum = 5;
// 
// void* threadTask(void *args)
// {
//     //std::string threadName = static_cast<char*>(args);
//     const char* threadName = static_cast<char*>(args);
//     while(true)
//     {
//         std::cout << "I am " << threadName << std::endl;
//         sleep(1);
//     }
//     delete []threadName;
//     return nullptr;
// }
// 
// 
// // 创建多线程
// int main()
// {
//     //char threadName[64];
//     std::vector<pthread_t> threads;
//     for(int i = 0; i < threadNum; i++)
//     {
//         //char threadName[64];
//         char* threadName = new char[64];
//         snprintf(threadName, 64, "thread-%d", i + 1);
//         pthread_t tid;
//         pthread_create(&tid, nullptr, threadTask, threadName);
//         threads.push_back(tid);
//     }
// 
//     for(auto& id: threads)
//     {
//         pthread_join(id, nullptr);
//     }
//     return 0;
// }

// std::string ToHex(pthread_t tid)
// {
//     char id[64];
//     snprintf(id, sizeof(id), "0x%lx", tid);
//     return id;
// }
// 
// 
// int global_val = 10;
// 
// void* threadRun(void* args)
// {
//     std::string threadName = (char*)args;
//     int cnt = 1;
//     while(cnt)
//     {
//         printf("new thread, g_val:%d, &g_val:%p\n", global_val, &global_val);
//         global_val++;
//         sleep(1);
//         if(cnt > 5)
//             break;
//         cnt++;
//     }
//     return (void*)123;
// }
// 
// 
// // 3.进程地址空间资源共享验证
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRun, (void*)"thread-1");
//     int cnt = 10;
//     while(cnt)
//     {
//         printf("main thread, g_val:%d, &g_val:%p\n", global_val, &global_val);
//         sleep(1);
//         cnt--;
//     }
//     return 0;
// }

// void* threadRun(void* args)
// {
//     std::string threadName = (char*)args;
//     int cnt = 1;
//     while(cnt)
//     {
//         std::cout << "I am " << threadName << " " << cnt << ", pid: " << getpid() << ", threadID: " << ToHex(pthread_self()) << std::endl;
//         sleep(1);
//         if(cnt > 5)
//             break;
//         cnt++;
//     }
//     return (void*)123;
// }
// 
// 
// // 2.线程等待
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRun, (void*)"thread-1");
//     void* ret = nullptr;
//     int n = pthread_join(tid, &ret);
//     std::cout << "main thread quit, n = " << n << " main thread get a ret: " << (long long)ret << std::endl; 
//     sleep(3);
//     return 0;
// }


// void* threadRun(void* args)
// {
//     int cnt = 1;
//     while(cnt)
//     {
//         std::cout << "I am new thread" << cnt << ", pid: " << getpid() << ", threadID: " << ToHex(pthread_self()) << std::endl;
//         sleep(1);
//         if(cnt > 5)
//             break;
//         cnt++;
//     }
//     return nullptr;
// }
// 
// 
// // 1.线程ID问题
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRun, nullptr);
//     int cnt = 10;
//     while(cnt)
//     {
//         std::cout << "I am main thread" << cnt << ", pid: " << getpid() << ", new threadID: " << ToHex(tid) << std::endl;
//         cnt--;
//         sleep(1);
//     }
//     return 0;
// }
